package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade CLASSE_VOLUME_VAZAO_TEMPO
 * @author Gerado pelo Telescope
 */
public class EntClasseVolumeVazaoTempo extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.CLASSE_VOLUME_VAZAO_TEMPO";
    public final static String TABLE_NAME = "CLASSE_VOLUME_VAZAO_TEMPO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntClasseVolumeVazaoTempo() {
        super();
        initialize();
    }
    
    public EntClasseVolumeVazaoTempo(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aVazaoLitrosHora = new DomDouble(this,"VAZAO_LITROS_HORA", "Vazão (Litros/hora)"); 
        aVazaoLitrosHora.setRequired(true);
        oVazaoLitrosHora = new DomDouble();
        aVolumesLitros = new DomDouble(this,"VOLUMES_LITROS", "Volumes (litros)"); 
        aVolumesLitros.setRequired(true);
        oVolumesLitros = new DomDouble();
        aTempoMinimo = new DomDouble(this,"TEMPO_MINIMO", "Tempo mínimo (segundos)"); 
        aTempoMinimo.setRequired(true);
        oTempoMinimo = new DomDouble();
        aTempoMaximo = new DomDouble(this,"TEMPO_MAXIMO", "Tempo mínimo (segundos)"); 
        aTempoMaximo.setRequired(true);
        oTempoMaximo = new DomDouble();
        aSiglaVazao = new DomUpper(this,"SIGLA_VAZAO", "Sigla da vazão"); 
        aSiglaVazao.setRequired(true);
        oSiglaVazao = new DomUpper();
        aClasseModeloId = new DomId(this,"CLASSE_MODELO_ID", "Classe do modelo"); 
        aClasseModeloId.setRequired(true);
        oClasseModeloId = new DomId();
        aVazaoNominal = new DomDouble(this,"VAZAO_NOMINAL", "Vazão nominal (m3/h)"); 
        aVazaoNominal.setRequired(true);
        oVazaoNominal = new DomDouble();
        aPontoExecucaoId = new DomId(this,"PONTO_EXECUCAO_ID", "Ponto de execução"); 
        aPontoExecucaoId.setRequired(true);
        oPontoExecucaoId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Vazão (Litros/hora)
    private DomDouble aVazaoLitrosHora;
    private DomDouble oVazaoLitrosHora;
    
    // Volumes (litros)
    private DomDouble aVolumesLitros;
    private DomDouble oVolumesLitros;
    
    // Tempo mínimo (segundos)
    private DomDouble aTempoMinimo;
    private DomDouble oTempoMinimo;
    
    // Tempo mínimo (segundos)
    private DomDouble aTempoMaximo;
    private DomDouble oTempoMaximo;
    
    // Sigla da vazão
    private DomUpper aSiglaVazao;
    private DomUpper oSiglaVazao;
    
    // Classe do modelo
    private DomId aClasseModeloId;
    private DomId oClasseModeloId;
    
    // Vazão nominal (m3/h)
    private DomDouble aVazaoNominal;
    private DomDouble oVazaoNominal;
    
    // Ponto de execução
    private DomId aPontoExecucaoId;
    private DomId oPontoExecucaoId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntClasseVolumeVazaoTempo id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VAZAO_LITROS_HORA">
    
    public EntClasseVolumeVazaoTempo vazaoLitrosHora(Double value) {
        setVazaoLitrosHora(value);
        return this;
    }
    
    public void setVazaoLitrosHora(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyVazaoLitrosHora();
        } else {
            aVazaoLitrosHora.setValue(value.getValue());
            if (aVazaoLitrosHora.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVazaoLitrosHora(String value) {
        if (value == null) {
            nullifyVazaoLitrosHora();
        } else {
            aVazaoLitrosHora.setValue(value);
            if (aVazaoLitrosHora.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVazaoLitrosHora(Double value) {
        aVazaoLitrosHora.setValue(value);
        if (aVazaoLitrosHora.isModified()) {
            setModified(true);
        }
    }
    
    public void setVazaoLitrosHora(Object value) {
        aVazaoLitrosHora.setValue(value);
        if (aVazaoLitrosHora.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVazaoLitrosHora() {
        if (!aVazaoLitrosHora.isNull()) {
            aVazaoLitrosHora.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getVazaoLitrosHora() {
        return aVazaoLitrosHora;
    }
    
    public DomDouble oldVazaoLitrosHora() {
        return oVazaoLitrosHora;
    }
    
    public Double valueOfVazaoLitrosHora() {
        return aVazaoLitrosHora.getValue();
    }
    
    public boolean isVazaoLitrosHoraModified() {
        return aVazaoLitrosHora.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VOLUMES_LITROS">
    
    public EntClasseVolumeVazaoTempo volumesLitros(Double value) {
        setVolumesLitros(value);
        return this;
    }
    
    public void setVolumesLitros(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyVolumesLitros();
        } else {
            aVolumesLitros.setValue(value.getValue());
            if (aVolumesLitros.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVolumesLitros(String value) {
        if (value == null) {
            nullifyVolumesLitros();
        } else {
            aVolumesLitros.setValue(value);
            if (aVolumesLitros.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVolumesLitros(Double value) {
        aVolumesLitros.setValue(value);
        if (aVolumesLitros.isModified()) {
            setModified(true);
        }
    }
    
    public void setVolumesLitros(Object value) {
        aVolumesLitros.setValue(value);
        if (aVolumesLitros.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVolumesLitros() {
        if (!aVolumesLitros.isNull()) {
            aVolumesLitros.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getVolumesLitros() {
        return aVolumesLitros;
    }
    
    public DomDouble oldVolumesLitros() {
        return oVolumesLitros;
    }
    
    public Double valueOfVolumesLitros() {
        return aVolumesLitros.getValue();
    }
    
    public boolean isVolumesLitrosModified() {
        return aVolumesLitros.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TEMPO_MINIMO">
    
    public EntClasseVolumeVazaoTempo tempoMinimo(Double value) {
        setTempoMinimo(value);
        return this;
    }
    
    public void setTempoMinimo(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyTempoMinimo();
        } else {
            aTempoMinimo.setValue(value.getValue());
            if (aTempoMinimo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTempoMinimo(String value) {
        if (value == null) {
            nullifyTempoMinimo();
        } else {
            aTempoMinimo.setValue(value);
            if (aTempoMinimo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTempoMinimo(Double value) {
        aTempoMinimo.setValue(value);
        if (aTempoMinimo.isModified()) {
            setModified(true);
        }
    }
    
    public void setTempoMinimo(Object value) {
        aTempoMinimo.setValue(value);
        if (aTempoMinimo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTempoMinimo() {
        if (!aTempoMinimo.isNull()) {
            aTempoMinimo.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getTempoMinimo() {
        return aTempoMinimo;
    }
    
    public DomDouble oldTempoMinimo() {
        return oTempoMinimo;
    }
    
    public Double valueOfTempoMinimo() {
        return aTempoMinimo.getValue();
    }
    
    public boolean isTempoMinimoModified() {
        return aTempoMinimo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TEMPO_MAXIMO">
    
    public EntClasseVolumeVazaoTempo tempoMaximo(Double value) {
        setTempoMaximo(value);
        return this;
    }
    
    public void setTempoMaximo(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyTempoMaximo();
        } else {
            aTempoMaximo.setValue(value.getValue());
            if (aTempoMaximo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTempoMaximo(String value) {
        if (value == null) {
            nullifyTempoMaximo();
        } else {
            aTempoMaximo.setValue(value);
            if (aTempoMaximo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTempoMaximo(Double value) {
        aTempoMaximo.setValue(value);
        if (aTempoMaximo.isModified()) {
            setModified(true);
        }
    }
    
    public void setTempoMaximo(Object value) {
        aTempoMaximo.setValue(value);
        if (aTempoMaximo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTempoMaximo() {
        if (!aTempoMaximo.isNull()) {
            aTempoMaximo.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getTempoMaximo() {
        return aTempoMaximo;
    }
    
    public DomDouble oldTempoMaximo() {
        return oTempoMaximo;
    }
    
    public Double valueOfTempoMaximo() {
        return aTempoMaximo.getValue();
    }
    
    public boolean isTempoMaximoModified() {
        return aTempoMaximo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SIGLA_VAZAO">
    
    public EntClasseVolumeVazaoTempo siglaVazao(String value) {
        setSiglaVazao(value);
        return this;
    }
    
    public void setSiglaVazao(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifySiglaVazao();
        } else {
            aSiglaVazao.setValue(value.getValue());
            if (aSiglaVazao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSiglaVazao(String value) {
        if (value == null) {
            nullifySiglaVazao();
        } else {
            aSiglaVazao.setValue(value);
            if (aSiglaVazao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSiglaVazao(Object value) {
        aSiglaVazao.setValue(value);
        if (aSiglaVazao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySiglaVazao() {
        if (!aSiglaVazao.isNull()) {
            aSiglaVazao.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getSiglaVazao() {
        return aSiglaVazao;
    }
    
    public DomUpper oldSiglaVazao() {
        return oSiglaVazao;
    }
    
    public String valueOfSiglaVazao() {
        return aSiglaVazao.getValue();
    }
    
    public boolean isSiglaVazaoModified() {
        return aSiglaVazao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CLASSE_MODELO_ID">
    
    public EntClasseVolumeVazaoTempo classeModeloId(Long value) {
        setClasseModeloId(value);
        return this;
    }
    
    public void setClasseModeloId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyClasseModeloId();
        } else {
            aClasseModeloId.setValue(value.getValue());
            if (aClasseModeloId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setClasseModeloId(String value) {
        if (value == null) {
            nullifyClasseModeloId();
        } else {
            aClasseModeloId.setValue(value);
            if (aClasseModeloId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setClasseModeloId(Long value) {
        aClasseModeloId.setValue(value);
        if (aClasseModeloId.isModified()) {
            setModified(true);
        }
    }
    
    public void setClasseModeloId(Object value) {
        aClasseModeloId.setValue(value);
        if (aClasseModeloId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyClasseModeloId() {
        if (!aClasseModeloId.isNull()) {
            aClasseModeloId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getClasseModeloId() {
        return aClasseModeloId;
    }
    
    public DomId oldClasseModeloId() {
        return oClasseModeloId;
    }
    
    public Long valueOfClasseModeloId() {
        return aClasseModeloId.getValue();
    }
    
    public boolean isClasseModeloIdModified() {
        return aClasseModeloId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VAZAO_NOMINAL">
    
    public EntClasseVolumeVazaoTempo vazaoNominal(Double value) {
        setVazaoNominal(value);
        return this;
    }
    
    public void setVazaoNominal(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyVazaoNominal();
        } else {
            aVazaoNominal.setValue(value.getValue());
            if (aVazaoNominal.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVazaoNominal(String value) {
        if (value == null) {
            nullifyVazaoNominal();
        } else {
            aVazaoNominal.setValue(value);
            if (aVazaoNominal.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVazaoNominal(Double value) {
        aVazaoNominal.setValue(value);
        if (aVazaoNominal.isModified()) {
            setModified(true);
        }
    }
    
    public void setVazaoNominal(Object value) {
        aVazaoNominal.setValue(value);
        if (aVazaoNominal.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVazaoNominal() {
        if (!aVazaoNominal.isNull()) {
            aVazaoNominal.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getVazaoNominal() {
        return aVazaoNominal;
    }
    
    public DomDouble oldVazaoNominal() {
        return oVazaoNominal;
    }
    
    public Double valueOfVazaoNominal() {
        return aVazaoNominal.getValue();
    }
    
    public boolean isVazaoNominalModified() {
        return aVazaoNominal.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PONTO_EXECUCAO_ID">
    
    public EntClasseVolumeVazaoTempo pontoExecucaoId(Long value) {
        setPontoExecucaoId(value);
        return this;
    }
    
    public void setPontoExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPontoExecucaoId();
        } else {
            aPontoExecucaoId.setValue(value.getValue());
            if (aPontoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPontoExecucaoId(String value) {
        if (value == null) {
            nullifyPontoExecucaoId();
        } else {
            aPontoExecucaoId.setValue(value);
            if (aPontoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPontoExecucaoId(Long value) {
        aPontoExecucaoId.setValue(value);
        if (aPontoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPontoExecucaoId(Object value) {
        aPontoExecucaoId.setValue(value);
        if (aPontoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPontoExecucaoId() {
        if (!aPontoExecucaoId.isNull()) {
            aPontoExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPontoExecucaoId() {
        return aPontoExecucaoId;
    }
    
    public DomId oldPontoExecucaoId() {
        return oPontoExecucaoId;
    }
    
    public Long valueOfPontoExecucaoId() {
        return aPontoExecucaoId.getValue();
    }
    
    public boolean isPontoExecucaoIdModified() {
        return aPontoExecucaoId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("UK_TAXVAZ_CLASSE_VAZAO") >= 0) {
                e = new AdsException("ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.UK_TAXVAZ_CLASSE_VAZAO", 
                        Severity.ERROR,
                        "Registro duplicado! Classe, vazão nominal, sigla e ponto de teste devem ser únicos. Classe do modelo ${CLASSE_MODELO_ID}, Vazão nominal (m3/h) ${VAZAO_NOMINAL}, Sigla da vazão ${SIGLA_VAZAO}, Ponto de execução ${PONTO_EXECUCAO_ID} (UK_TAXVAZ_CLASSE_VAZAO)");
                return e;
            } else if (msg.indexOf("FK_TAXVAZ_PONTO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.FK_TAXVAZ_PONTO_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PONTO_EXECUCAO! (FK_TAXVAZ_PONTO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_TAXVAZ_CLASSE_MODELO") >= 0) {
                e = new AdsException("ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.FK_TAXVAZ_CLASSE_MODELO", 
                        Severity.ERROR,
                        "Registro não cadastrado para CLASSE_MODELO! (FK_TAXVAZ_CLASSE_MODELO)");
                return e;
            } else if (msg.indexOf("PK_TAXVAZ") >= 0) {
                e = new AdsException("ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.PK_TAXVAZ", 
                        Severity.ERROR,
                        "ID duplicado! (PK_TAXVAZ)");
                return e;
            } else {
                e = new AdsException("ZTEST.CLASSE_VOLUME_VAZAO_TEMPO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aVazaoLitrosHora);
            allAttributes.add(aVolumesLitros);
            allAttributes.add(aTempoMinimo);
            allAttributes.add(aTempoMaximo);
            allAttributes.add(aSiglaVazao);
            allAttributes.add(aClasseModeloId);
            allAttributes.add(aVazaoNominal);
            allAttributes.add(aPontoExecucaoId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getClasseModeloId().toString() +
                " " + getVazaoNominal().toString() +
                " " + getSiglaVazao().toString() +
                " " + getPontoExecucaoId().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByClasseModeloIdVazaoNominalSiglaVazaoPontoExecucaoId(long classeModeloId, double vazaoNominal, String siglaVazao, long pontoExecucaoId) throws AdsException {
        findBy(new String[] {"CLASSE_MODELO_ID", "VAZAO_NOMINAL", "SIGLA_VAZAO", "PONTO_EXECUCAO_ID"},
                new Object[] {classeModeloId, vazaoNominal, siglaVazao, pontoExecucaoId});
    }
    
    private EntPontoExecucao ePontoExecucao;
    
    public EntPontoExecucao findPontoExecucao() throws AdsException {
        if (getPontoExecucaoId().isNull()) {
            return null;
        }
        if (ePontoExecucao == null || !valueOfPontoExecucaoId().equals(ePontoExecucao.valueOfId())) {
            ePontoExecucao = new EntPontoExecucao(ctx);
            ePontoExecucao.find(valueOfPontoExecucaoId());
        }
        return ePontoExecucao;
    }
    
    /**
     * Ativa o join desta entidade com PONTO_EXECUCAO
     * através do atributo PONTO_EXECUCAO_ID
     */
    public EntPontoExecucao joinPontoExecucao() {
        return joinPontoExecucao(null);
    }
    public EntPontoExecucao joinPontoExecucao(String alias) {
        EntPontoExecucao entity = new EntPontoExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPontoExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPontoExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from CLASSE_VOLUME_VAZAO_TEMPO where PONTO_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPontoExecucao(long id) throws AdsException {
        findByPontoExecucao(id,"");
    }
    
    public void findByPontoExecucao(Entity entidade) throws AdsException {
        findByPontoExecucao(entidade.valueOfId(),"");
    }
    
    public void findByPontoExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByPontoExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntClasseModelo eClasseModelo;
    
    public EntClasseModelo findClasseModelo() throws AdsException {
        if (getClasseModeloId().isNull()) {
            return null;
        }
        if (eClasseModelo == null || !valueOfClasseModeloId().equals(eClasseModelo.valueOfId())) {
            eClasseModelo = new EntClasseModelo(ctx);
            eClasseModelo.find(valueOfClasseModeloId());
        }
        return eClasseModelo;
    }
    
    /**
     * Ativa o join desta entidade com CLASSE_MODELO
     * através do atributo CLASSE_MODELO_ID
     */
    public EntClasseModelo joinClasseModelo() {
        return joinClasseModelo(null);
    }
    public EntClasseModelo joinClasseModelo(String alias) {
        EntClasseModelo entity = new EntClasseModelo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getClasseModeloId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByClasseModelo(long id, String sqlAppend) throws AdsException {
        find("select ID from CLASSE_VOLUME_VAZAO_TEMPO where CLASSE_MODELO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByClasseModelo(long id) throws AdsException {
        findByClasseModelo(id,"");
    }
    
    public void findByClasseModelo(Entity entidade) throws AdsException {
        findByClasseModelo(entidade.valueOfId(),"");
    }
    
    public void findByClasseModelo(Entity entidade, String sqlAppend) throws AdsException {
        findByClasseModelo(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        ePontoExecucao = null;
        eClasseModelo = null;
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oVazaoNominal.setValue(aVazaoNominal);
        oTempoMaximo.setValue(aTempoMaximo);
        oTempoMinimo.setValue(aTempoMinimo);
        oVazaoLitrosHora.setValue(aVazaoLitrosHora);
        oVolumesLitros.setValue(aVolumesLitros);
        oPontoExecucaoId.setValue(aPontoExecucaoId);
        oSiglaVazao.setValue(aSiglaVazao);
        oClasseModeloId.setValue(aClasseModeloId);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntClasseVolumeVazaoTempo.class);
            rule.setName("PK_TAXVAZ");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntClasseVolumeVazaoTempo.class);
            rule.setAssociatedEntity(EntClasseModelo.class);
            rule.setName("FK_TAXVAZ_CLASSE_MODELO");
            rule.addAttribute(new DomId("CLASSE_MODELO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntClasseVolumeVazaoTempo.class);
            rule.setAssociatedEntity(EntPontoExecucao.class);
            rule.setName("FK_TAXVAZ_PONTO_EXECUCAO");
            rule.addAttribute(new DomId("PONTO_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntClasseVolumeVazaoTempo.class);
            rule.setName("UK_TAXVAZ_CLASSE_VAZAO");
            rule.addAttribute(new DomId("CLASSE_MODELO_ID",""));
            rule.addAttribute(new DomDouble("VAZAO_NOMINAL",""));
            rule.addAttribute(new DomUpper("SIGLA_VAZAO",""));
            rule.addAttribute(new DomId("PONTO_EXECUCAO_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
